package com.atzxh.heima.algorithm;


import java.util.Arrays;
import java.util.Iterator;
import java.util.function.Consumer;
import java.util.stream.IntStream;

/**
 * @author 小红同学
 * @date 2023-08-28-22:08
 * @description     动态数组
 */
public class DynamicArray implements Iterable<Integer>{
    private int size = 0; // 逻辑大小
    private int capacity = 10; // 数组起始容量
    private int[] array = {};

    /**
     * 添加
     * @param element   每次添加的元素
     */
    public void addLast(int element) {
//        array[size] = element;
//        size++;
        add(size,element);
    }

    /**
     * 添加到指定的数组位置
     * @param index 指定的位置
     * @param element   准备添加的元素
     */
    public void add(int index, int element) {
        // 检查容量
        checkCapacity();
        // index边界问题
        if (index >= 0 && index <= size) {
            System.arraycopy(array, index, array, index + 1, size - index);
        } else {
            return;
        }
        array[index] = element;
        size++;
    }

    private void checkCapacity() {
        // 容量检查
        if (size == 0) {
            // 首次添加才对数组进行初始化
            array = new int[capacity];
        }else if (size == capacity) {
            // 此时需要扩容
            capacity += capacity >> 1;
            int[] newArray = new int[capacity];
            System.arraycopy(array, 0, newArray, 0, size);
            array = newArray;
        }
    }

    /**
     *  查询元素
     * @param index [0...size)
     * @return 该索引位置的元素
     */
    public int get(int index) {
        if (index >= 0 && index <= size)
            return  array[index];
        else
            return -1;
    }

    /**
     *  遍历方法1
     * @param consumer 遍历要执行的操作     入参：每一个元素
     */
    public void foreach(Consumer<Integer> consumer) {
        for (int i = 0; i < size; i++) {
//            System.out.println(array[i]);
            consumer.accept(array[i]);
        }
    }

    /**
     *  迭代器遍历
     * @return 迭代器对象
     */
    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            int i = 0;
            @Override
            public boolean hasNext() {  // 判断有没有下一个元素
                return i < size;
            }

            @Override
            public Integer next() {     // 返回当前元素，并指向下一个元素
                return array[i++];
            }
        };
    }

    /**
     * stream流遍历
     * @return  stream对象
     */
    public IntStream stream() {
        return IntStream.of(Arrays.copyOfRange(array,0,size));
    }

    public int remove(int index) {  // [0,size)
        int removed = array[index];
        if (index < size - 1) {
            System.arraycopy(array,index + 1, array, index, size - index - 1);
        }
        size--;
        return removed;
    }
}

